// 合唱队
// 具体描述情打开链接查看
// 测试链接 : https://www.luogu.com.cn/problem/P3205
// 提交以下的所有代码，可以直接通过

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 1001;
const int MOD = 19650827;
int dp[MAXN][2];
int n, nums[MAXN];

int read()
{
    char ch = getchar();
    int x = 0, f = 1;
    while(ch < '0' || ch > '9')
    {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
        x = 10 * x + ch - '0';
        ch = getchar();
    }
    return f * x;
}

// 时间复杂度O(n^2)
// 严格位置依赖的动态规划
int compute1()
{
    int dp[n + 1][n + 1][2];
    memset(dp, 0, sizeof dp);
    // 人的编号范围 : 1...n
    // dp[l][r][0] : 形成l...r的状况的方法数，同时要求l位置的数字是最后出现的
    // dp[l][r][1] : 形成l...r的状况的方法数，同时要求r位置的数字是最后出现的
    for(int i = 1; i < n; ++i)
    {
        if(nums[i] < nums[i + 1])
        {
            dp[i][i + 1][0] = 1;
            dp[i][i + 1][1] = 1;
        }
    }

    // dp[l][r][0] dp[l + 1][r][0] dp[l + 1][r][1]
    // dp[l][r][1] dp[l][r - 1][0] dp[l][r - 1][0]
    // 一个位置依赖其下面的位置和左边的位置
    for(int l = n - 2; l >= 1; --l)
    {
        for(int r = l + 2; r <= n; ++r)
        {
            // 最后出现的数字是 nums[l]
            if(nums[l] < nums[l + 1]) // nums[l + 1] 是上一个出现的数字
                dp[l][r][0] = (dp[l][r][0] + dp[l + 1][r][0]) % MOD;
            if(nums[l] < nums[r]) // nums[r] 是上一个出现的数字
                dp[l][r][0] = (dp[l][r][0] + dp[l + 1][r][1]) % MOD;
            // 最后出现的数字是 nums[r]
            if(nums[r] > nums[l]) // nums[l] 是上一个出现的数字
                dp[l][r][1] = (dp[l][r][1] + dp[l][r - 1][0]) % MOD;
            if(nums[r] > nums[r - 1]) // nums[r - 1] 是上一个出现的数字
                dp[l][r][1] = (dp[l][r][1] + dp[l][r - 1][1]) % MOD;
        }
    }
    return (dp[1][n][0] + dp[1][n][1]) % MOD;
}

// 时间复杂度O(n^2)
// 空间压缩
int compute2()
{
    // dp[n - 1][n][0] dp[n - 1][n][1]
    if(nums[n - 1] < nums[n])
    {
        dp[n][0] = 1;
        dp[n][1] = 1;
    }
    for(int l = n - 2; l >= 1; --l)
    {
        // dp[l][l + 1][0] dp[l][l + 1][1]
        if(nums[l] < nums[l + 1])
            dp[l + 1][0] = 1, dp[l + 1][1] = 1;
        else
            dp[l + 1][0] = 0, dp[l + 1][1] = 0;
        // 求 dp[r][0], dp[r][1]
        for(int r = l + 2; r <= n; ++r)
        {
            int a = 0, b = 0;
            if(nums[l] < nums[l + 1])
                a = (a + dp[r][0]) % MOD;
            if(nums[l] < nums[r])
                a = (a + dp[r][1]) % MOD;
            if(nums[r] > nums[l])
                b = (b + dp[r - 1][0]) % MOD;
            if(nums[r] > nums[r - 1])
                b = (b + dp[r - 1][1]) % MOD;
            
            dp[r][0] = a;
            dp[r][1] = b;
        }
    }
    return (dp[n][0] + dp[n][1]) % MOD;
}

int main()
{
    n = read();
    for(int i = 1; i <= n; ++i) nums[i] = read();
    if(n == 1) puts("1");
    else printf("%d\n", compute2());

    return 0;
}